home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / lang / ThreadGroup.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  6.3 KB  |  557 lines
  1. package java.lang;
  2.  
  3. import java.io.PrintStream;
  4. import java.util.Arrays;
  5. import sun.misc.VM;
  6.  
  7. public class ThreadGroup implements Thread.UncaughtExceptionHandler {
  8.    ThreadGroup parent;
  9.    String name;
  10.    int maxPriority;
  11.    boolean destroyed;
  12.    boolean daemon;
  13.    boolean vmAllowSuspension;
  14.    int nUnstartedThreads;
  15.    int nthreads;
  16.    Thread[] threads;
  17.    int ngroups;
  18.    ThreadGroup[] groups;
  19.  
  20.    private ThreadGroup() {
  21.       this.nUnstartedThreads = 0;
  22.       this.name = "system";
  23.       this.maxPriority = 10;
  24.    }
  25.  
  26.    public ThreadGroup(String var1) {
  27.       this(Thread.currentThread().getThreadGroup(), var1);
  28.    }
  29.  
  30.    public ThreadGroup(ThreadGroup var1, String var2) {
  31.       this.nUnstartedThreads = 0;
  32.       if (var1 == null) {
  33.          throw new NullPointerException();
  34.       } else {
  35.          var1.checkAccess();
  36.          this.name = var2;
  37.          this.maxPriority = var1.maxPriority;
  38.          this.daemon = var1.daemon;
  39.          this.vmAllowSuspension = var1.vmAllowSuspension;
  40.          this.parent = var1;
  41.          var1.add(this);
  42.       }
  43.    }
  44.  
  45.    public final String getName() {
  46.       return this.name;
  47.    }
  48.  
  49.    public final ThreadGroup getParent() {
  50.       if (this.parent != null) {
  51.          this.parent.checkAccess();
  52.       }
  53.  
  54.       return this.parent;
  55.    }
  56.  
  57.    public final int getMaxPriority() {
  58.       return this.maxPriority;
  59.    }
  60.  
  61.    public final boolean isDaemon() {
  62.       return this.daemon;
  63.    }
  64.  
  65.    public synchronized boolean isDestroyed() {
  66.       return this.destroyed;
  67.    }
  68.  
  69.    public final void setDaemon(boolean var1) {
  70.       this.checkAccess();
  71.       this.daemon = var1;
  72.    }
  73.  
  74.    public final void setMaxPriority(int var1) {
  75.       int var2;
  76.       ThreadGroup[] var3;
  77.       synchronized(this) {
  78.          this.checkAccess();
  79.          if (var1 < 1) {
  80.             this.maxPriority = 1;
  81.          } else if (var1 < this.maxPriority) {
  82.             this.maxPriority = var1;
  83.          }
  84.  
  85.          var2 = this.ngroups;
  86.          if (this.groups != null) {
  87.             var3 = (ThreadGroup[])Arrays.copyOf(this.groups, var2);
  88.          } else {
  89.             var3 = null;
  90.          }
  91.       }
  92.  
  93.       for(int var4 = 0; var4 < var2; ++var4) {
  94.          var3[var4].setMaxPriority(var1);
  95.       }
  96.  
  97.    }
  98.  
  99.    public final boolean parentOf(ThreadGroup var1) {
  100.       while(var1 != null) {
  101.          if (var1 == this) {
  102.             return true;
  103.          }
  104.  
  105.          var1 = var1.parent;
  106.       }
  107.  
  108.       return false;
  109.    }
  110.  
  111.    public final void checkAccess() {
  112.       SecurityManager var1 = System.getSecurityManager();
  113.       if (var1 != null) {
  114.          var1.checkAccess(this);
  115.       }
  116.  
  117.    }
  118.  
  119.    public int activeCount() {
  120.       int var1;
  121.       int var2;
  122.       ThreadGroup[] var3;
  123.       synchronized(this) {
  124.          if (this.destroyed) {
  125.             return 0;
  126.          }
  127.  
  128.          var1 = this.nthreads;
  129.          var2 = this.ngroups;
  130.          if (this.groups != null) {
  131.             var3 = (ThreadGroup[])Arrays.copyOf(this.groups, var2);
  132.          } else {
  133.             var3 = null;
  134.          }
  135.       }
  136.  
  137.       for(int var4 = 0; var4 < var2; ++var4) {
  138.          var1 += var3[var4].activeCount();
  139.       }
  140.  
  141.       return var1;
  142.    }
  143.  
  144.    public int enumerate(Thread[] var1) {
  145.       this.checkAccess();
  146.       return this.enumerate((Thread[])var1, 0, true);
  147.    }
  148.  
  149.    public int enumerate(Thread[] var1, boolean var2) {
  150.       this.checkAccess();
  151.       return this.enumerate((Thread[])var1, 0, var2);
  152.    }
  153.  
  154.    private int enumerate(Thread[] var1, int var2, boolean var3) {
  155.       int var4 = 0;
  156.       ThreadGroup[] var5 = null;
  157.       synchronized(this) {
  158.          if (this.destroyed) {
  159.             return 0;
  160.          }
  161.  
  162.          int var7 = this.nthreads;
  163.          if (var7 > var1.length - var2) {
  164.             var7 = var1.length - var2;
  165.          }
  166.  
  167.          for(int var8 = 0; var8 < var7; ++var8) {
  168.             if (this.threads[var8].isAlive()) {
  169.                var1[var2++] = this.threads[var8];
  170.             }
  171.          }
  172.  
  173.          if (var3) {
  174.             var4 = this.ngroups;
  175.             if (this.groups != null) {
  176.                var5 = (ThreadGroup[])Arrays.copyOf(this.groups, var4);
  177.             } else {
  178.                var5 = null;
  179.             }
  180.          }
  181.       }
  182.  
  183.       if (var3) {
  184.          for(int var6 = 0; var6 < var4; ++var6) {
  185.             var2 = var5[var6].enumerate(var1, var2, true);
  186.          }
  187.       }
  188.  
  189.       return var2;
  190.    }
  191.  
  192.    public int activeGroupCount() {
  193.       int var1;
  194.       ThreadGroup[] var2;
  195.       synchronized(this) {
  196.          if (this.destroyed) {
  197.             return 0;
  198.          }
  199.  
  200.          var1 = this.ngroups;
  201.          if (this.groups != null) {
  202.             var2 = (ThreadGroup[])Arrays.copyOf(this.groups, var1);
  203.          } else {
  204.             var2 = null;
  205.          }
  206.       }
  207.  
  208.       int var3 = var1;
  209.  
  210.       for(int var4 = 0; var4 < var1; ++var4) {
  211.          var3 += var2[var4].activeGroupCount();
  212.       }
  213.  
  214.       return var3;
  215.    }
  216.  
  217.    public int enumerate(ThreadGroup[] var1) {
  218.       this.checkAccess();
  219.       return this.enumerate((ThreadGroup[])var1, 0, true);
  220.    }
  221.  
  222.    public int enumerate(ThreadGroup[] var1, boolean var2) {
  223.       this.checkAccess();
  224.       return this.enumerate((ThreadGroup[])var1, 0, var2);
  225.    }
  226.  
  227.    private int enumerate(ThreadGroup[] var1, int var2, boolean var3) {
  228.       int var4 = 0;
  229.       ThreadGroup[] var5 = null;
  230.       synchronized(this) {
  231.          if (this.destroyed) {
  232.             return 0;
  233.          }
  234.  
  235.          int var7 = this.ngroups;
  236.          if (var7 > var1.length - var2) {
  237.             var7 = var1.length - var2;
  238.          }
  239.  
  240.          if (var7 > 0) {
  241.             System.arraycopy(this.groups, 0, var1, var2, var7);
  242.             var2 += var7;
  243.          }
  244.  
  245.          if (var3) {
  246.             var4 = this.ngroups;
  247.             if (this.groups != null) {
  248.                var5 = (ThreadGroup[])Arrays.copyOf(this.groups, var4);
  249.             } else {
  250.                var5 = null;
  251.             }
  252.          }
  253.       }
  254.  
  255.       if (var3) {
  256.          for(int var6 = 0; var6 < var4; ++var6) {
  257.             var2 = var5[var6].enumerate(var1, var2, true);
  258.          }
  259.       }
  260.  
  261.       return var2;
  262.    }
  263.  
  264.    /** @deprecated */
  265.    @Deprecated
  266.    public final void stop() {
  267.       if (this.stopOrSuspend(false)) {
  268.          Thread.currentThread().stop();
  269.       }
  270.  
  271.    }
  272.  
  273.    public final void interrupt() {
  274.       int var1;
  275.       ThreadGroup[] var2;
  276.       synchronized(this) {
  277.          this.checkAccess();
  278.  
  279.          for(int var4 = 0; var4 < this.nthreads; ++var4) {
  280.             this.threads[var4].interrupt();
  281.          }
  282.  
  283.          var1 = this.ngroups;
  284.          if (this.groups != null) {
  285.             var2 = (ThreadGroup[])Arrays.copyOf(this.groups, var1);
  286.          } else {
  287.             var2 = null;
  288.          }
  289.       }
  290.  
  291.       for(int var3 = 0; var3 < var1; ++var3) {
  292.          var2[var3].interrupt();
  293.       }
  294.  
  295.    }
  296.  
  297.    /** @deprecated */
  298.    @Deprecated
  299.    public final void suspend() {
  300.       if (this.stopOrSuspend(true)) {
  301.          Thread.currentThread().suspend();
  302.       }
  303.  
  304.    }
  305.  
  306.    private boolean stopOrSuspend(boolean var1) {
  307.       boolean var2 = false;
  308.       Thread var3 = Thread.currentThread();
  309.       ThreadGroup[] var5 = null;
  310.       int var4;
  311.       synchronized(this) {
  312.          this.checkAccess();
  313.  
  314.          for(int var7 = 0; var7 < this.nthreads; ++var7) {
  315.             if (this.threads[var7] == var3) {
  316.                var2 = true;
  317.             } else if (var1) {
  318.                this.threads[var7].suspend();
  319.             } else {
  320.                this.threads[var7].stop();
  321.             }
  322.          }
  323.  
  324.          var4 = this.ngroups;
  325.          if (this.groups != null) {
  326.             var5 = (ThreadGroup[])Arrays.copyOf(this.groups, var4);
  327.          }
  328.       }
  329.  
  330.       for(int var6 = 0; var6 < var4; ++var6) {
  331.          var2 = var5[var6].stopOrSuspend(var1) || var2;
  332.       }
  333.  
  334.       return var2;
  335.    }
  336.  
  337.    /** @deprecated */
  338.    @Deprecated
  339.    public final void resume() {
  340.       int var1;
  341.       ThreadGroup[] var2;
  342.       synchronized(this) {
  343.          this.checkAccess();
  344.  
  345.          for(int var4 = 0; var4 < this.nthreads; ++var4) {
  346.             this.threads[var4].resume();
  347.          }
  348.  
  349.          var1 = this.ngroups;
  350.          if (this.groups != null) {
  351.             var2 = (ThreadGroup[])Arrays.copyOf(this.groups, var1);
  352.          } else {
  353.             var2 = null;
  354.          }
  355.       }
  356.  
  357.       for(int var3 = 0; var3 < var1; ++var3) {
  358.          var2[var3].resume();
  359.       }
  360.  
  361.    }
  362.  
  363.    public final void destroy() {
  364.       int var1;
  365.       ThreadGroup[] var2;
  366.       synchronized(this) {
  367.          this.checkAccess();
  368.          if (this.destroyed || this.nthreads > 0) {
  369.             throw new IllegalThreadStateException();
  370.          }
  371.  
  372.          var1 = this.ngroups;
  373.          if (this.groups != null) {
  374.             var2 = (ThreadGroup[])Arrays.copyOf(this.groups, var1);
  375.          } else {
  376.             var2 = null;
  377.          }
  378.  
  379.          if (this.parent != null) {
  380.             this.destroyed = true;
  381.             this.ngroups = 0;
  382.             this.groups = null;
  383.             this.nthreads = 0;
  384.             this.threads = null;
  385.          }
  386.       }
  387.  
  388.       for(int var3 = 0; var3 < var1; ++var3) {
  389.          var2[var3].destroy();
  390.       }
  391.  
  392.       if (this.parent != null) {
  393.          this.parent.remove(this);
  394.       }
  395.  
  396.    }
  397.  
  398.    private final void add(ThreadGroup var1) {
  399.       synchronized(this) {
  400.          if (this.destroyed) {
  401.             throw new IllegalThreadStateException();
  402.          } else {
  403.             if (this.groups == null) {
  404.                this.groups = new ThreadGroup[4];
  405.             } else if (this.ngroups == this.groups.length) {
  406.                this.groups = (ThreadGroup[])Arrays.copyOf(this.groups, this.ngroups * 2);
  407.             }
  408.  
  409.             this.groups[this.ngroups] = var1;
  410.             ++this.ngroups;
  411.          }
  412.       }
  413.    }
  414.  
  415.    private void remove(ThreadGroup var1) {
  416.       synchronized(this) {
  417.          if (!this.destroyed) {
  418.             for(int var3 = 0; var3 < this.ngroups; ++var3) {
  419.                if (this.groups[var3] == var1) {
  420.                   --this.ngroups;
  421.                   System.arraycopy(this.groups, var3 + 1, this.groups, var3, this.ngroups - var3);
  422.                   this.groups[this.ngroups] = null;
  423.                   break;
  424.                }
  425.             }
  426.  
  427.             if (this.nthreads == 0) {
  428.                this.notifyAll();
  429.             }
  430.  
  431.             if (this.daemon && this.nthreads == 0 && this.nUnstartedThreads == 0 && this.ngroups == 0) {
  432.                this.destroy();
  433.             }
  434.  
  435.          }
  436.       }
  437.    }
  438.  
  439.    void addUnstarted() {
  440.       synchronized(this) {
  441.          if (this.destroyed) {
  442.             throw new IllegalThreadStateException();
  443.          } else {
  444.             ++this.nUnstartedThreads;
  445.          }
  446.       }
  447.    }
  448.  
  449.    void add(Thread var1) {
  450.       synchronized(this) {
  451.          if (this.destroyed) {
  452.             throw new IllegalThreadStateException();
  453.          } else {
  454.             if (this.threads == null) {
  455.                this.threads = new Thread[4];
  456.             } else if (this.nthreads == this.threads.length) {
  457.                this.threads = (Thread[])Arrays.copyOf(this.threads, this.nthreads * 2);
  458.             }
  459.  
  460.             this.threads[this.nthreads] = var1;
  461.             ++this.nthreads;
  462.             --this.nUnstartedThreads;
  463.          }
  464.       }
  465.    }
  466.  
  467.    void remove(Thread var1) {
  468.       synchronized(this) {
  469.          if (!this.destroyed) {
  470.             for(int var3 = 0; var3 < this.nthreads; ++var3) {
  471.                if (this.threads[var3] == var1) {
  472.                   System.arraycopy(this.threads, var3 + 1, this.threads, var3, --this.nthreads - var3);
  473.                   this.threads[this.nthreads] = null;
  474.                   break;
  475.                }
  476.             }
  477.  
  478.             if (this.nthreads == 0) {
  479.                this.notifyAll();
  480.             }
  481.  
  482.             if (this.daemon && this.nthreads == 0 && this.nUnstartedThreads == 0 && this.ngroups == 0) {
  483.                this.destroy();
  484.             }
  485.  
  486.          }
  487.       }
  488.    }
  489.  
  490.    public void list() {
  491.       this.list(System.out, 0);
  492.    }
  493.  
  494.    void list(PrintStream var1, int var2) {
  495.       int var3;
  496.       ThreadGroup[] var4;
  497.       synchronized(this) {
  498.          for(int var6 = 0; var6 < var2; ++var6) {
  499.             var1.print(" ");
  500.          }
  501.  
  502.          var1.println(this);
  503.          var2 += 4;
  504.  
  505.          for(int var11 = 0; var11 < this.nthreads; ++var11) {
  506.             for(int var7 = 0; var7 < var2; ++var7) {
  507.                var1.print(" ");
  508.             }
  509.  
  510.             var1.println(this.threads[var11]);
  511.          }
  512.  
  513.          var3 = this.ngroups;
  514.          if (this.groups != null) {
  515.             var4 = (ThreadGroup[])Arrays.copyOf(this.groups, var3);
  516.          } else {
  517.             var4 = null;
  518.          }
  519.       }
  520.  
  521.       for(int var5 = 0; var5 < var3; ++var5) {
  522.          var4[var5].list(var1, var2);
  523.       }
  524.  
  525.    }
  526.  
  527.    public void uncaughtException(Thread var1, Throwable var2) {
  528.       if (this.parent != null) {
  529.          this.parent.uncaughtException(var1, var2);
  530.       } else {
  531.          Thread.UncaughtExceptionHandler var3 = Thread.getDefaultUncaughtExceptionHandler();
  532.          if (var3 != null) {
  533.             var3.uncaughtException(var1, var2);
  534.          } else if (!(var2 instanceof ThreadDeath)) {
  535.             System.err.print("Exception in thread \"" + var1.getName() + "\" ");
  536.             var2.printStackTrace(System.err);
  537.          }
  538.       }
  539.  
  540.    }
  541.  
  542.    /** @deprecated */
  543.    @Deprecated
  544.    public boolean allowThreadSuspension(boolean var1) {
  545.       this.vmAllowSuspension = var1;
  546.       if (!var1) {
  547.          VM.unsuspendSomeThreads();
  548.       }
  549.  
  550.       return true;
  551.    }
  552.  
  553.    public String toString() {
  554.       return this.getClass().getName() + "[name=" + this.getName() + ",maxpri=" + this.maxPriority + "]";
  555.    }
  556. }
  557.